// debugger

import $constant from '@/utils/open/constant'
import $common from '@/utils/open/common'
import $validate from '@/utils/open/validate'

const regSecialSymbols = /(\n|\r|\r\n|↵)/g // 正则：换行符等
let num2 = 0
export default {
  // 获取静态资源数据
  getStaticData (fn) {
    // debugger
    if (!$constant._staticTimer) { // 当页面应用，避免每次路由跳转都初始化数据
      $constant._staticTimer = setInterval(() => {
        // window.gData
        // if (!$validate.isNull(window.gData)) {
        if (window.isLoadDataOver) {
          // debugger

          clearInterval($constant._staticTimer)
          // $constant._staticTimer = null
          // debugger
          const arr = []
          for (const value in window.gData) {
            const tt = window.gData[value]
            tt.date = value
            arr.push(tt)
          }
          // debugger

          this.recurtionInitData(arr, 0, () => {
            // debugger

            fn && fn()
          })
        } else {
          console.log('等待数据加载完毕', num2)
          num2++
        }
      }, 1000)
    } else {
      fn && fn()
    }
  },
  // 处理答案 对应的章节数据
  initChapterData (date, data) {
    // debugger
    if (!$constant.charpterExamNum[date]) {
      $constant.charpterExamNum[date] = {}
    }
    // 根据换行符，拆成数组
    const list = []
    let arr = []
    arr = data.split(',')
    // debugger
    if (arr.length <= 2) { // 章节数大于14
      arr = data.split(regSecialSymbols)
    }
    // console.log(arr);
    // debugger
    // let charpterNum = 0
    // 剔除数组的空元素
    arr = arr.filter(function (s) {
      return s && s.trim()
    })
    for (let i = 0; i < arr.length; i++) {
      const o = arr[i]
      if (o && !regSecialSymbols.test(o)) {
        let val = o.split(/\s/g)
        // console.log('1.',o);
        val = val.filter(function (s) {
          return s && s.trim()
        })
        let charpterNum = val[1] // 章节序号
        // debugger
        if ($validate.isNull(charpterNum)) {
          val.some(a => {
            if (!$validate.isNull(a)) {
              charpterNum = a
              return true
            }
          })
        }
        // debugger

        try {
          // 注意：章节数是从1开始，索引是从0开始
          let firstN = charpterNum.split('.')[0]
          // eslint-disable-next-line
          if (firstN == '敏捷实践指南') { // 敏捷没有章节数
            // debugger
            firstN = $constant.chapterList.length
          } else {
            firstN = Number(firstN)
          }
          // debugger
          if (!$constant.charpterExamNum[date][firstN]) {
            $constant.charpterExamNum[date][firstN] = {
              allNum: 0
            }
          }

          $constant.charpterExamNum[date][firstN].allNum++

          const curChaObj = $constant.chapterList[firstN - 1] // 取单一章节数据
          // debugger
          list.push({
            label: curChaObj.label,
            answer: val[0].toUpperCase(),
            chapter: charpterNum
          })
        } catch (error) {
          console.error(error)
          debugger
        }
      }
    }

    // debugger
    return list
  },

  recurtionInitData (arr, index, fn) {
    if (index < arr.length) {
      const item = arr[index]

      const { date, rightAnswerA, rigthAnswer, allData, testQuestion } = item
      // debugger
      const { tableData } = this.initData({ allData, testQuestion }, { rigthAnswer, rightAnswerA, curDate: date })
      // debugger
      if ($validate.isNull($constant.loadAllData[date])) {
        $constant.loadAllData[date] = {
          tableData: []
        }
      }

      $constant.loadAllData[date].tableData = tableData
      index++
      this.recurtionInitData(arr, index, fn)
    } else {
      // debugger
      // 等所有数据都加载完毕，再统计考生考试次数，总平均分
      for (const date in $constant.loadAllData) {
        const item = $constant.loadAllData[date]
        const tbData = item.tableData
        tbData.forEach(row => {
          const stuName = row.stuName
          const { stuExamNum, avg } = this.analyzeStuAll({ date, stuName: stuName }) // 统计考生多次答题情况，按章节划分
          row.avg = avg
          row.stuExamNum = stuExamNum
        })
      }
      fn && fn()
    }
  },
  // 处理答案，有的答案中有中英文括号
  execuAnswerbrackets (str) {
    let rigthList = []
    // const letterReg = /\((.+?)\)[A-Z|a-z]+/g // 英文字母正则匹配

    if (!$validate.isNull(str)) { // 不能为空
      const regex1 = /(?<=\(|\（)(.+?)(?=\)|\）)/g // 是否存在中英文括号
      // const letterReg = /\((.+?)\)|\（(.+?)\）|[A-Z|a-z]+/g // 英文字母正则匹配
      // const letterReg = /[\(|\（](.+?)[\)|\）] | [A-Z|a-z]+/g // 英文字母正则匹配
      const letterReg = /(\(|\（)(.+?)(\)|\）)|[A-Z|a-z]+/g // 中英文括号+英文字母正则匹配

      const rightArr = str.match(letterReg)

      if ($validate.isNull(rightArr)) {
        return rigthList
      }

      if (regex1.test(str)) { // 存在中英文括号(是多选的情况)
        // debugger

        // 包含 中英文 括号的
        const reg1 = /\((.+?)\)/g // 判断是否存在 英文的括号
        const reg2 = /\（(.+?)\）/g // 判断是否存在 中文的括号

        // 不包含 中英文 括号的
        const reg11 = /(?<=\()(.+?)(?=\))/g // 英文
        const reg22 = /(?<=\（)(.+?)(?=\）)/g // 中文
        const reg33 = /(\(|\（)(.+?)(\)|\）)/g // 中文 + 英文 括号混合
        rightArr.forEach(o => {
          const t1 = reg1.test(o) // 是否存在 英文
          const t2 = reg2.test(o) // 是否存在 中文
          const t3 = reg33.test(o) //  中文 + 英文 括号混合

          if (t1) { // 英文
            const v1 = o.match(reg11).map(r => r.toUpperCase())
            rigthList = rigthList.concat('(' + v1 + ')')
            // debugger
          } else if (t2) { // 中文
            const v2 = o.match(reg22).map(r => r.toUpperCase())
            rigthList = rigthList.concat('(' + v2 + ')')
            // debugger
          } else if (t3) { // 中英文括号混合（多选题）
            // let v3 = o.replace(/[\(\（\(\）]/g, '') // 把中英文括号替换掉
            const v3 = o.replace(/[\（]/g, '(').replace(/[\）]/g, ')') // 把中文括号替换掉
            rigthList.push(v3.toUpperCase())
            // debugger
          } else {
            if (o.length > 1) { // 字符数大于1才需要拆解
              const arr = o.split('').map(r => r.toUpperCase())
              rigthList = rigthList.concat(arr)
            } else if (o.length > 0) {
              rigthList.push(o.toUpperCase())
            }

            // debugger
          }
        })
      } else { // 没有中英文括号
        try {
          rigthList = rightArr.join('').split('').map(o => o.toUpperCase()) // 统一转大写
        } catch (error) {
          console.error(error)
          // debugger
        }
      }
    }
    return rigthList
  },
  // 按答题批次，整合题目相关数据
  initTestQuestion ({ testQuestion, curDate }) {
    if (!$constant.subjectAllList[curDate]) {
      $constant.subjectAllList[curDate] = []
    }
    // const list1 = testQuestion.replace(regSecialSymbols, '') // 剔除换行符等特殊字符
    const list2 = testQuestion.split('==-=--=')
    const list3 = []
    // debugger
    list2.forEach((o, i) => {
      const arr = o.split('|*|*|').map(a => a.replace(/^\s*|\s*$/g, '')) // 拆分题目和答案，并且剔除开头和末尾空字符
      const obj = {
        subjectIndex: i,
        subject: arr[0], // 题目
        answerAnalysis: arr[1] // 答案分析
      }
      // debugger
      list3.push(obj)
    })

    $constant.subjectAllList[curDate] = list3
    return list3
  },
  // 初始化表格数据
  initData ({ allData, testQuestion }, { rigthAnswer, rightAnswerA, curDate }) {
    const nameAnswer = allData // 接龙数据 姓名+答案
    // debugger
    let curCharpterAnswerList = [] // 按日期分类，本次章节答题数据: 索引对应题目序号，题目的答案，题目对应的章节名称
    const newRightArr = this.execuAnswerbrackets(rigthAnswer)
    if (!$constant.rightAswerObj[curDate]) {
      $constant.rightAswerObj[curDate] = newRightArr
    }
    // debugger
    this.initTestQuestion({ testQuestion, curDate })
    // console.log('$constant.subjectAllList', $constant.subjectAllList);
    // console.log('curDate', curDate);
    // debugger

    // 题目的正确答案，和对应的章节
    if (!$constant.chapterAnswerData[curDate]) {
      $constant.chapterAnswerData[curDate] = []
    }
    // debugger
    // 处理本次答案 对应的章节数据
    if (rightAnswerA) {
      curCharpterAnswerList = this.initChapterData(curDate, rightAnswerA)
      // debugger
      $constant.chapterAnswerData[curDate] = curCharpterAnswerList
    }

    // 题目数对应的考生答题情况
    // debugger
    if (!$constant.subjectData[curDate]) {
      $constant.subjectData[curDate] = {}
    }
    // debugger
    curCharpterAnswerList.forEach((o, i) => {
      if (!$constant.subjectData[curDate][i]) {
        // debugger
        $constant.subjectData[curDate][i] = { // 每道题，对应的答对答错统计
          chapIndex: 0, // 章节索引
          errNum: 0,
          successNum: 0,
          allNum: 0,
          typeA: 0, // 答案选项
          typeB: 0, // 答案选项
          typeC: 0, // 答案选项
          typeD: 0 // 答案选项
        }
      }
    })

    // debugger
    // console.log(nameAnswer);

    // 根据换行符，拆成数组
    // const regEng = /[^a-zA-Z]/g
    const chinaReg = /[\u4e00-\u9fa5]+/g
    // const letterReg = /(\(|\（)(.+?)(\)|\）)|[A-Z|a-z]+/g // 中英文括号+英文字母正则匹配
    const stuInfoList = [] // 所有考生答题数据数组，就是每个考生的接龙字符数据：序号名字答案
    let nameAnswerArr = nameAnswer.split(regSecialSymbols)
    // 剔除数组的空元素
    nameAnswerArr = nameAnswerArr.filter(function (s) {
      return s && s.trim()
    })
    // debugger
    // console.log(nameAnswerArr);
    nameAnswerArr.forEach(o => {
      if (o && !regSecialSymbols.test(o)) {
        stuInfoList.push(o)
      }
    })

    // console.log('stuInfoList:', stuInfoList);
    // 剔除名字前的序号
    const stuScoreData = {} // 学生本次答题数据
    // debugger
    let spaceName = 0 // 接龙会有空白名字情况
    stuInfoList.forEach(originData => {
      let hasData = ''
      // debugger
      if (originData) {
        hasData = originData.replace(regSecialSymbols, '')
      }
      // debugger
      if (hasData) {
        let stuNameAndAnswerArr = ''
        try {
          stuNameAndAnswerArr = hasData.split(' ') // 每个学生接龙的数据，拆成数组： [序号，名字，答案]
          stuNameAndAnswerArr = stuNameAndAnswerArr.filter(function (s) {
            return s && s.trim()
          })
        } catch (error) {
          console.error(error)
          // debugger
        }
        // console.log(stuNameAndAnswerArr.length, stuNameAndAnswerArr);
        let stuName = stuNameAndAnswerArr[1] // 接龙的格式，默认是： 序号.stuName 答案。 比如： 1.张三 abcdd abede
        // debugger
        // 统计考生答题次数
        if (rightAnswerA) {
          if (!$constant.userOtherInfo[stuName]) {
            $constant.userOtherInfo[stuName] = {
              examNum: 0
            }
          }
          $constant.userOtherInfo[stuName].examNum++
        }

        // 名字为空
        if ($validate.isNull(stuName)) {
          //   debugger
          stuName = spaceName + '.名字空白'
          spaceName++
        }

        // debugger
        const arr1111 = stuNameAndAnswerArr.reverse() // 取反后，从末尾取答案。
        // debugger
        //
        // console.log(stuNameAndAnswerArr);
        let studentAnswerList = [] // 获取考生答案
        const newArr0 = []
        if (!stuScoreData[stuName]) { // 按名字统计，避免重复
          // debugger
          arr1111.some(a => {
            let str = a
            if (regSecialSymbols.test(a)) { // 剔除 回车，换行符等
              str = a.replace(regSecialSymbols, '')
              // debugger
            }

            if (chinaReg.test(a)) { // 剔除中文
              str = a.replace(chinaReg, '')
              // debugger
            }

            const asList = this.execuAnswerbrackets(str)
            // debugger
            // 3. loading ACCC ADCAB
            const studentAnswerList1 = []
            if (asList.length > 0) {
              for (const o of asList) {
                // const o = asList[i]
                // debugger
                if (newArr0.length < newRightArr.length) { // 匹配到的字符答案为正确答案个数，就停止匹配，
                  studentAnswerList1.push(o)
                  newArr0.push(o)
                } else {
                  // debugger
                  break
                }
              }
            }
            // debugger
            studentAnswerList = $common.flatten([...studentAnswerList1, studentAnswerList])
            // debugger
            if (studentAnswerList.length >= newRightArr.length) { // 匹配到的字符答案为正确答案个数，就停止匹配，
              return true
            }
          })

          // debugger
          if (studentAnswerList.length > 0) {
            // debugger

            // 计算正确率
            let score = 0
            let scoreHtml = ''
            // 遍历正确答案
            newRightArr.forEach((rightAnswer, i) => {
              const stuVal = studentAnswerList[i] // 考生每题的答案选项

              // debugger
              let error = 'error-cls'

              let curChapter = null
              let chaNum = 100 // 章节号（若有100章节号，则说明有错）
              // debugger
              if (curCharpterAnswerList.length > 0) {
                // 匹配每道题对应的章节
                let cha1 = ''
                try {
                  const anCha = curCharpterAnswerList[i]
                  // debugger
                  cha1 = anCha.chapter.split('.')
                } catch (error) {
                  console.error(error)
                }

                // eslint-disable-next-line
                if (cha1 == '敏捷实践指南') {
                  // debugger
                  curChapter = $constant.chapterList[$constant.chapterList.length - 1] // 章节
                  chaNum = $constant.chapterList.length - 1
                } else {
                  chaNum = Number(cha1[0]) - 1

                  curChapter = $constant.chapterList[chaNum] // 章节
                }
              }
              // debugger
              if (!$constant.countAllData[curDate]) {
                $constant.countAllData[curDate] = {}
              }
              // debugger
              if (!$constant.countAllData[curDate][chaNum]) {
                $constant.countAllData[curDate][chaNum] = {
                  rightAnswer, // 正确答案
                  allNum: 0,
                  successNum: 0,
                  errorNum: 0,
                  curChapter
                }
              }

              // debugger
              try {
                $constant.countAllData[curDate][chaNum].allNum++
                $constant.subjectData[curDate][i].allNum++ // 每道题总数
                $constant.subjectData[curDate][i].chapIndex = chaNum // 章节号
                const typeName = 'type' + stuVal
                // debugger
                $constant.subjectData[curDate][i][typeName]++
                // debugger
                // typeA
              } catch (error) {
                debugger
              }
              // if (stuName === 'NICOLE') {
              //   debugger
              // }
              // debugger
              let isSuccess = false
              if (rightAnswer === stuVal) { // 答对
                isSuccess = true
                $constant.countAllData[curDate][chaNum].successNum++
                score++
                $constant.subjectData[curDate][i].successNum++ // 统计每道题目，答对答错人数

                error = ''
              } else { // 答错
                $constant.subjectData[curDate][i].errNum++ // 统计每道题目，答对答错人数
                // debugger
                $constant.countAllData[curDate][chaNum].errorNum++
              }

              // debugger
              this.countErrNum({ curDate, stuName, curChapter, isSuccess }) // 统计 每个人错对应的章节
              // debugger
              //
              scoreHtml += '<span class="score-cls ' + error + '" title="第' + (i + 1) + '题">' + (stuVal || 'x') + '</span>'
            })
            // console.log(studentAnswerList);
            const scoreNum = score / newRightArr.length * 100 + '%'
            // debugger
            $constant.analysisUserData[stuName][curDate].score = scoreNum
            // debugger
            stuScoreData[stuName] = {
              date: curDate, // 日期
              originData,
              stuName,
              studentAnswerList,
              scoreHtml,
              rightNum: score,
              score: scoreNum
            }
          }
        } else { // 监听重复名字
          // , originData, stuScoreData
          console.error('学生名字重复了', curDate, 'stuName:', stuName)
        }

        // 补齐本次未有涉及题目的章节
        const analyStu = $constant.analysisUserData[stuName]
        // debugger
        try {
          if (analyStu && analyStu[curDate]) {
            var analyseData = analyStu[curDate].chapterList
            if (analyseData) {
              // debugger
              $constant.chapterList.forEach(chapterItem => {
                const cpIndex = chapterItem.value
                const dd = analyseData[cpIndex]
                // debugger
                if (!dd) {
                  // console.log(stuName, 'cpIndex', cpIndex);
                  analyseData[cpIndex] = chapterItem
                  analyseData[cpIndex].curCpErrNum = 0
                  analyseData[cpIndex].curCpSuccessNum = 0
                }
                // debugger
              })
            }
          }
        } catch (error) {
          debugger
        }
        // debugger
      }
    })

    // console.log('stuScoreData', stuScoreData);

    // 整成表格数据
    const tableData = []
    // curDate
    // debugger
    for (const name in stuScoreData) {
      const row = stuScoreData[name]
      tableData.push(row)
    }
    // debugger
    // 从大到小排序
    tableData.sort((data1, data2) => {
      return data2.rightNum - data1.rightNum
    })

    // console.log(curDate, '******tableData', tableData);

    // console.log('2.initData');
    return {
      tableData
    }
  },
  // 统计 每个人错题对应的章节
  countErrNum ({ curDate, stuName, curChapter, isSuccess }) {
    // if(curDate === '20221018' && name === '易江涛'){
    // }
    // debugger
    if (!curChapter) return
    // 统计错题对应的章节

    // 按姓名分
    if (!$constant.analysisUserData[stuName]) {
      // debugger
      $constant.analysisUserData[stuName] = {}
    }

    // 按日期分
    if (!$constant.analysisUserData[stuName][curDate]) {
      $constant.analysisUserData[stuName][curDate] = {
        chapterList: [],
        score: 0, // 本次答题正确率
        successNum: 0, // 本次答题错对数据
        errNum: 0 // 本次答题错对数据
      }
    }
    let curChapter1 = null
    if (!$constant.analysisUserData[stuName][curDate].chapterList[curChapter.value]) {
      // debugger
      curChapter1 = { ...curChapter }
      curChapter1.curCpAllNum = 0 // 统计当前章节错对数
      curChapter1.curCpErrNum = 0 // 统计当前章节错对数
      curChapter1.curCpSuccessNum = 0 // 统计当前章节错对数
      $constant.analysisUserData[stuName][curDate].chapterList[curChapter.value] = curChapter1
    } else {
      // debugger
      curChapter1 = $constant.analysisUserData[stuName][curDate].chapterList[curChapter.value]
    }

    curChapter1.curCpAllNum++
    if (isSuccess) {
      curChapter1.curCpSuccessNum++
      $constant.analysisUserData[stuName][curDate].successNum++
    } else {
      curChapter1.curCpErrNum++
      $constant.analysisUserData[stuName][curDate].errNum++
    }

    // debugger
  },
  // 统计考生多次答题情况，按章节划分
  analyzeStuAll ({ date, stuName }) {
    let stuExamNum = 0 // 答题次数
    let allScore = 0 // 所有次数的总分数
    const stuExamData = {} // 按章节，统计考生所有答题
    const allExam = $constant.analysisUserData[stuName] // 按考生姓名

    const curStu = $constant.userOtherInfo[stuName]
    if (!curStu.chapterData) {
      // debugger
      curStu.chapterData = {}
    }

    if (!curStu.chapterData[date]) {
      // debugger
      curStu.chapterData[date] = {}
    }

    let stuExamList = []
    // debugger
    for (const date in allExam) { // 按日期（这里的日期是考试类型）
      const chapObj = allExam[date] // 按章节
      stuExamNum++
      allScore += chapObj.score ? parseInt(chapObj.score) : 0
      for (const chapIndex in chapObj.chapterList) {
        const examItem = chapObj.chapterList[chapIndex]
        // debugger
        if (!stuExamData[chapIndex]) {
          stuExamData[chapIndex] = {
            curCpAllNum: 0, // 出题次数
            curCpErrNum: 0,
            curCpSuccessNum: 0,
            chapterName: examItem.label,
            chapterIndex: examItem.value
          }
        }
        // debugger
        stuExamData[chapIndex].curCpAllNum += examItem.curCpErrNum + examItem.curCpSuccessNum
        stuExamData[chapIndex].curCpErrNum += examItem.curCpErrNum
        stuExamData[chapIndex].curCpSuccessNum += examItem.curCpSuccessNum
      }
    }

    // 计算某次考试，每章节正确率
    const otherList = []
    for (const index in stuExamData) {
      const obj = stuExamData[index]
      // debugger
      if (obj.curCpAllNum > 0) {
        obj.successRatio = parseInt(obj.curCpSuccessNum / obj.curCpAllNum * 10000) / 100
        stuExamList.push(obj)
      } else {
        obj.successRatio = 0
        otherList.push(obj)
      }
    }
    // debugger
    // 按成功率更高排序
    stuExamList.sort((a, b) => b.successRatio - a.successRatio)
    stuExamList = stuExamList.concat(otherList) // 加入本次未出过题的章节数据

    // 平均分（所有章节答题正确数/答题次数）
    const avg = parseInt(allScore / stuExamNum * 100) / 100

    curStu.chapterData[date] = stuExamList
    // debugger
    return {
      avg,
      stuExamList,
      stuExamNum
    }
  },
  /**
   * 动态加载资源
   * @param {String} src 资源路径
   * @param {Function} callback 回调函数
   */
  loadScript (src, date, callback) {
    const head = document.getElementsByTagName('head')[0]
    let scriptDom = null
    if ($constant.loadAllData[date]) { // 存在，则剔除
      // debugger
      // head.removeChild($constant.loadAllData[date].dom)
      // scriptDom = document.createElement('script') // 位置不能动，需要重新加载数据
      callback()
      return
    } else {
      scriptDom = document.createElement('script') // 位置不能动，需要重新加载数据
      $constant.loadAllData[date] = {
        dom: scriptDom,
        date
      }
    }
    // debugger
    scriptDom.type = 'text/javascript'
    scriptDom.charset = 'UTF-8'
    scriptDom.setAttribute('defer', true)
    // scriptDom.src = src + '?times=' + Math.random()
    scriptDom.src = src
    // debugger
    // console.log('scriptDom', scriptDom)
    if (scriptDom.addEventListener) {
      scriptDom.addEventListener('load', function () {
        // debugger
        callback()
      }, false)
    } else if (scriptDom.attachEvent) {
      scriptDom.attachEvent('onreadystatechange', function () {
        const target = window.event.srcElement
        if (target.readyState === 'loaded') {
          // debugger
          callback()
        }
      })
    }

    head.appendChild(scriptDom)
  },
  // 获取题库的数据
  getSubject () {
    const subArr = []
    const subList = document.querySelectorAll('#div_subject_list .div_subject')
    subList.forEach(liDom => {
      const obj = {
        liDom: liDom,
        rowNum: 0, // 题号
        subDesc: '', // 问题描述
        opsList: [], // 答案选项
        stuAnswer: '', // 考生答案
        rightAnswer: '', // 正确答案
        analysis: '' // 解析说明
      }

      // 问题描述
      const rowDom = liDom.querySelector('.se_p .se_blue_text')
      obj.rowNum = rowDom.innerText

      // 问题描述
      const subDesc = liDom.querySelector('.se_p .v_question')
      obj.subDesc = subDesc.innerText

      // 答案选项
      const ops = liDom.querySelectorAll('.se_p .icheck-material-blue > label')
      // debugger
      ops.forEach(oLiDom => {
        var tt = oLiDom.innerText
        // console.log('ops:', tt);
        obj.opsList.push(tt)
        // debugger
      })

      // 考生答案
      const stuAnswerDom = liDom.querySelector('.v_examinee_answer.se_red_text')
      obj.stuAnswer = stuAnswerDom.innerText
      // debugger

      // 正确答案
      const rightAnswerDom = liDom.querySelector('.v_right_answer')
      obj.rightAnswer = rightAnswerDom.innerText
      // debugger

      // 正确答案
      const analysisDom = liDom.querySelector('.v_analysis')
      obj.analysis = analysisDom.innerText
      // debugger

      subArr.push(obj)
    })

    console.log('subArr', subArr)
  },
  // 从指定的字符中，通过正则获取章节数据
  // 比如： 知识点出处：PMBOK 6th 页码：P505 章节：13.1.2 识别相关方的迭代性：项目进入其生命周
  // 最后结果： 13.1.2
  getChapter (str) {
    var lastStr = ''
    // var str = '知识点出处：PMBOK 6th 页码：P505 章节：13.1.2 识别相关方的迭代性：项目进入其生命周'
    if ($validate.isNull(str)) {
      return lastStr
    }
    var val0 = str.split('章节：')
    console.log('val0：', val0)
    if (val0.length > 1) {
      var val1 = val0[1]
      console.log('val1：', val1)

      // var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）——|{}【】‘；：”“'。，、？]", 'g')
      var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\]<>/?~！@#￥……&*（）——|{}【】‘；：”“'。，、？]", 'g') // 已经去掉了一点
      if (pattern.test(val1)) {
        console.log('ok')
        var val2 = val1.replace(pattern, '')
        console.log('val2：', val2)
      }

      var val3 = val2.replace(/\s+/g, '')
      console.log('val3：', val3)

      var reg = /[\u4e00-\u9fa5]+/g // 匹配中文
      var val4 = val3.replace(reg, ' ')
      console.log('val4：', val4)

      var val5 = val4.split('.')
      console.log('val5：', val5)
      lastStr = val5
    }

    return lastStr
  },
  // 百度统计，受访页面表格的链接解码
  decodeUrl () {
    const tableDom = document.getElementById('table')
    const trList = tableDom.querySelectorAll('table .line')
    trList.forEach(trDom => {
      const urlDom = trDom.querySelector('.visit_page_title a')
      if (urlDom) {
        urlDom.innerText = decodeURI(urlDom.innerText)
      }

    })
  }

}
